\section{Point de départ: le langage \textsl{SL}}

Le langage dSL est en fait l'évolution du langage orienté objet \textsl{SL}. \textsl{SL} signifie \textsl{Supervision Language} et le `d' de \textsl{dSL} signifie \textsl{distributed}. Le langage \textsl{dSL} est donc, en quelque sorte, la version distribuée de \textsl{SL}, mais nous y reviendrons plus tard. Dans cette section, le langage \textsl{SL} sera présenté et, ensuite, les différents ajouts de \textsl{dSL} seront décrits. Cette section et la suivante sont, en fait, un résumé de~\cite{BDeW}. \\

Le langage \textsl{SL} ne peut pas être utilisé pour spécifier le comportement de toutes les entités qui composent le système à contrôler. En effet, ces entités sont de deux types: des contrôleurs avec une vision locale du système (limitée à ce qu'ils font) qui sont directement connectés à l'environnement et qui ne peuvent pas être programmés en \textsl{SL} et un superviseur qui commande les différents contrôleurs. Ce dernier a une vision globale du système et il peut être programmé en \textsl{SL}. L'utilisateur peut interagir avec le superviseur s'il désire avoir une vision du système contrôlé. Il y a donc deux types d'interaction dans un tel système: une interaction entre l'humain et le superviseur et des interactions entre le superviseur et les contrôleurs. Ces dernières se font via le réseau.

\subsection{Les contrôleurs}
Les contrôleurs, que l'on appelle aussi \textsl{PLC}, sont constitués, entre autres, d'appareils pour les entrées (permettant de collecter des informations sur l'environnement, comme la température, un niveau de liquide, une pression, ...) et les sorties (permettant d'agir sur l'environnement comme chauffer, ouvrir une vanne, ...). Ces contrôleurs n'ont qu'un ensemble d'instructions limité et doivent être programmés dans un langage ressemblant à de l'assembleur, ce qui n'est pas le cas du superviseur, qui peut être programmé en \textsl{SL}. Les contrôleurs n'ont qu'une vision locale du système. Ils peuvent avoir une vision globale du système en recevant les informations manquantes via leur interface de communication. Ces informations sont envoyées par le superviseur.

\subsection{Le superviseur}
Le superviseur est un serveur performant qui communique avec les différents contrôleurs au travers d'un réseau. Son rôle est de recevoir les statuts des environnements de chaque contrôleur, de construire sa propre vue globale du système grâce à ces informations et d'envoyer un message décrivant le comportement que chaque contrôleur doit adopter. Le langage \textsl{SL} est utilisé pour décrire le comportement de ce superviseur.

\subsection{Les variables}
Dans le langage \textsl{SL}, il y a deux catégories de variable: les variables internes et les variables externes. 

\subsubsection{Les variables internes}
Les variables internes sont des variables locales au programme \textsl{SL}, c'est-à-dire qu'elles ne sont utilisées que dans le programme \textsl{SL} et ne seront pas envoyées sur le réseau. Comme dans la plupart des langages de programmation, ces variables internes peuvent être locales à une routine ou globales à tout le programme.

\subsubsection{Les variables externes}
Il existe également des variables externes qui sont globales à tout le système. Parmi ces variables externes, on trouve des variables d'entrée (notées $Var^{in}$ dans la suite) ou des variables de sortie (notées $Var^{out}$ dans la suite). \\

Les variables d'entrée sont liées à l'état d'un senseur se trouvant sur un contrôleur. Ces variables ont pour fonction de retenir la valeur d'une donnée de l'environnement captée par ce senseur (comme, par exemple, la température, la pression, etc.). Lorsqu'un senseur lié à un contrôleur capte une valeur, le contrôleur envoie cette valeur sur le réseau vers le superviseur qui met à jour sa variable. \\

Les variables de sortie sont liées à un actionneur se trouvant sur un contrôleur. Ces variables peuvent être écrites et lues depuis le programme \textsl{SL}. Lorsque le programme modifie une telle variable, un message est envoyé sur le réseau vers le contrôleur. Celui-ci agit sur l'actionneur lié à la variable. Ce message change donc l'état de l'actionneur, ce qui permet au programme \textsl{SL} d'agir sur l'environnement. \\

Aucune différence n'existe, au niveau de la syntaxe, entre les variables internes et externes. Par contre, il existe une base de données, lisible par \textsl{SL}. Cette base de données permet d'interpréter les valeurs de variables reçues et d'identifier les liens qui existent entre les variables externes de sortie et les activateurs. Les contrôleurs doivent être programmés manuellement en utilisant un langage proche de l'assembleur. Lorsqu'une variable est transmise depuis un contrôleur vers le superviseur, \textsl{SL} lit et utilise la base de données pour savoir à quoi correspond la variable. Si le superviseur désire effectuer une action, il regarde, dans sa base de données, quel contrôleur peut agir sur l'activateur nécessaire à l'action, envoie un message pour modifier l'état de cet activateur et modifie la variable liée à celui-ci.

\subsection{Les \texttt{WHEN} et la sémantique des assignations}
Étant donné que \textsl{SL} est un langage de réaction à des changements d'environnement, il contient des structures d'instructions permettant cette réactivité. Les changements d'environnement sont appelés ``événements'' et sont, en \textsl{SL}, directement reliés à la réaction grâce à un certain type de bloc d'instruction: le bloc \texttt{WHEN}. La structure générale d'un \texttt{WHEN} est la suivante:

\begin{alltt}
	WHEN \(condition\) THEN \(instruction_list\) END_WHEN
\end{alltt}

On peut identifier deux parties dans cette structure: (i) la $condition$ qui représente l'événement à observer, et (ii) l'$instruction\_list$ qui contient l'ensemble des instructions permettant la réaction à cet évènement. Les \when d'un programme \textsl{SL} sont constamment observés, c'est-à-dire que les conditions sont tout le temps évaluées. Lorsque cette condition crée un flanc montant, c'est-à-dire lorsqu'elle passe de \texttt{FALSE} à \texttt{TRUE}, la liste d'instructions du corps du \when est exécutée (réaction à l'événement qui vient de se passer). Il est important que la réaction ne se fasse que sur les flancs montants des conditions et non pas chaque fois que la condition est vraie. En effet, étant donné que ces conditions sont évaluées à chaque moment, si une condition passe de \texttt{FALSE} à \texttt{TRUE}, le système réagit, mais cette réaction ne va pas faire passer instantanément la condition à \texttt{FALSE} (par exemple une température à faire repasser en dessous d'un seuil: ça prend du temps). Dès lors, les conditions auront le temps d'être ré-évaluées et la réaction sera à nouveau effectuée, ce qui n'est pas nécessaire. \\

Une assignation en \textsl{SL} est de la forme: \textsl{partie\_gauche} \texttt{:=} \textsl{partie\_droite} et a une sémantique particulière, en plus d'assigner la valeur de \textsl{partie\_droite} à \textsl{partie\_gauche}. En effet, chaque fois qu'une assignation est effectuée, tous les \when du programme sont évalués un par un, dans l'ordre d'apparition dans le code. Ils sont, si nécessaire, déclenchés (c'est-à-dire que la condition passe de \texttt{FALSE} à \texttt{TRUE}) dans ce même ordre.

\subsection{La valeur \texttt{UNKNOWN}}
Dans le langage \textsl{SL}, les variables de type de base (comme \texttt{BOOL}, \texttt{INT}, \texttt{REAL}, etc.) peuvent, en plus des valeurs accordées, avoir une valeur spéciale: la valeur \texttt{UNKNOWN}. Cette valeur inconnue modélise (i) une défaillance matérielle du contrôleur auquel la variable est liée ou (ii) une coupure de la communication avec le superviseur. De plus, la valeur \texttt{UNKNOWN} se propage par les instructions, c'est-à-dire que si une variable $v$ a une valeur inconnue et qu'une opération est réalisée entre $v$ et une constante $a$ ou même entre $v$ et une variable $x$ (de valeur connue ou inconnue), le résultat de cette opération sera inconnu, \texttt{UNKNOWN}.

\subsection{Exécution d'un programme \textsl{SL}}
Au départ du programme \textsl{SL}, une liste d'instructions est exécutées dans le but d'initialiser les différentes variables. Après cette phase d'initialisation, une boucle infinie est exécutée pour analyser les messages qui arrivent au superviseur (et sont rangés dans une file de type \textsl{FIFO}). L'analyse de ces messages se fait de la manière suivante: 
\begin{enumerate}
	\item Analyse du premier message (sous la forme $(x, v)$, $x$ étant une variable et $v$ sa nouvelle valeur) de la file ;
	\item Exécution de \texttt{x := v} ;
	\item Évaluation des conditions des \when et exécution des réactions si nécessaire ;
	\item Retour au point 1.
\end{enumerate}